---
title: lefthook
description: Kör automatiskt Ultracite på dina staged Git-filer med lefthook
---

Ultracite erbjuder sömlös integration med [lefthook](https://lefthook.dev/), en snabb och kraftfull hanterare för Git-hooks. Denna integration ställer automatiskt in pre-commit hooks för att säkerställa att din kod är korrekt formaterad innan varje commit.

## Vad är lefthook?

lefthook är en snabb, native hanterare för Git-hooks för Node.js- och Go-projekt. Den är designad för att vara enkel, snabb och kraftfull, och låter dig hantera Git-hooks i hela teamet med konfigurationsfiler som kan committas till ditt repository.

## Hur Ultracite använder lefthook

När du initierar Ultracite i ditt projekt kan det automatiskt konfigurera lefthook för att köra kodformatering före varje commit. Detta säkerställer att:

- All committad kod följer konsekventa formateringsstandarder
- Kodkvalitetskontroller upprätthålls automatiskt
- Teammedlemmar behöver inte komma ihåg att formatera koden manuellt
- Ditt repository bibehåller en ren och konsekvent kodstil

## Pre-commit-hookens beteende

Ultracites lefthook-integration skapar en pre-commit hook som kör följande kommando:

```bash
npx ultracite fix
```

Detta kommando:
- Kör Biome's linter och formatterare på din kodbas
- Åtgärdar formateringsproblem automatiskt där det är möjligt
- Säkerställer att alla staged filer uppfyller ditt projekts kodstandarder
- Förhindrar commits som skulle införa formateringsinkonsistenser

## Automatisk konfiguration

Under initialiseringsprocessen (`ultracite init`), om du väljer alternativet lefthook, så:

1. **Installerar lefthook**: Lägger till lefthook som en utvecklingsberoende i ditt projekt
2. **Initierar lefthook**: Kör `lefthook install` för att ställa in Git-hooks
3. **Skapar konfiguration**: Sätter upp filen `lefthook.yml` med formateringskommandot
4. **Hanterar befintliga konfigurationer**: Om du redan har lefthook konfigurerat uppdaterar den din befintliga konfiguration istället för att skriva över den

## Integrationsdetaljer

Lefthook-integrationen inkluderar flera smarta funktioner:

### Beroendehantering
- Installerar automatiskt lefthook som ett dev-beroende med ditt projekts paketchef
- Använder lämpligt paketchefskommando (`npm install -D`, `yarn add -D`, `pnpm add -D`, etc.)
- Kör `lefthook install` för att initiera Git-hooks

### Konfigurationshantering
- **Nya projekt**: Skapar en ny `lefthook.yml`-fil med ultracite fix-kommandot
- **Befintliga projekt**: Lägger till Ultracite-kommandot i din befintliga lefthook-konfiguration och bevarar andra hooks du kan ha konfigurerat

### Filstruktur
Integrationen skapar eller modifierar:
```
lefthook.yml    # Contains the formatting command configuration
```

## Fördelar

- **Konsistens i teamet**: Varje teammedlem får samma formatering tillämpad automatiskt
- **Ingen konfiguration**: Fungerar direkt med vettiga standardinställningar
- **Hög prestanda**: lefthook är skrivet i Go och är extremt snabbt
- **Flexibilitet**: Lätt att utöka med ytterligare kommandon och hooks
- **Plattformsoberoende**: Fungerar konsekvent över olika operativsystem

## Integrering i arbetsflödet

Lefthook-integrationen smälter sömlöst in i ditt utvecklingsarbetsflöde:

1. **Utvecklaren gör ändringar** i kodfiler
2. **Lägger till filer** för commit med `git add`
3. **Försöker committa** med `git commit`
4. **lefthook triggar** pre-commit hook automatiskt
5. **Ultracite körs** och formaterar de staged filerna
6. **Commit fortsätter** om formateringen lyckas, eller **misslyckas** om det finns problem som inte kunde autofixas

## Anpassning

Medan Ultracite ställer in förnuftiga standarder kan du anpassa beteendet:

- Modifiera `lefthook.yml` för att lägga till ytterligare kommandon eller hooks
- Konfigurera Biome-inställningar för att justera formateringsregler
- Lägg till andra pre-commit-kontroller tillsammans med Ultracites formattering
- Använd lefthooks kraftfulla parallella exekvering och villkorslogik

## Felsökning

### Hooken körs inte
Om pre-commit hooken inte körs:
- Säkerställ att lefthook är installerat: `npm ls lefthook`
- Kontrollera att `lefthook.yml` finns och innehåller ultracite-kommandot
- Verifiera att Git-hooks är aktiverade i ditt repository
- Kör `lefthook install` för att installera hooks igen

### Behörighetsproblem
lefthook hanterar Git-hook-behörigheter automatiskt, men om du stöter på problem:
- Försök köra `lefthook install` igen
- Kontrollera att din Git-konfiguration tillåter hooks

### Hoppa över hooks
I sällsynta fall där du behöver kringgå pre-commit hooken:
```bash
git commit --no-verify
```

Använd detta sparsamt, eftersom det kringgår den automatiska formatteringen som håller din kodbas konsekvent.

## Konfigurationsexempel

Här är hur `lefthook.yml`-konfigurationen ser ut:

```yaml
pre-commit:
  jobs:
    - run: npx ultracite fix
      glob: 
        - "*.js"
        - "*.jsx"
        - "*.ts"
        - "*.tsx"
        - "*.json"
        - "*.jsonc"
        - "*.css"
      stage_fixed: true
```

Denna konfiguration:
- Kör endast på JavaScript-, TypeScript-, JSON- och CSS-filer
- Lägger automatiskt till filer som åtgärdats av formatteraren till staged
- Använder den effektiva `jobs`-syntaksen för bättre prestanda

Du kan utöka denna konfiguration för att inkludera ytterligare jobb:

```yaml
pre-commit:
  jobs:
    - run: npx ultracite fix
      glob: 
        - "*.js"
        - "*.jsx"
        - "*.ts"
        - "*.tsx"
        - "*.json"
        - "*.jsonc"
        - "*.css"
      stage_fixed: true
    - run: npm test
      glob: "*.{js,ts}"
    - run: tsc --noEmit
      glob: "*.{ts,tsx}"
```